home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / samba.idb / usr / samba / src / source / pipes.c.z / pipes.c
Encoding:
C/C++ Source or Header  |  1998-10-28  |  8.5 KB  |  323 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    Pipe SMB reply routines
  5.    Copyright (C) Andrew Tridgell 1992-1998
  6.    Copyright (C) Luke Kenneth Casson Leighton 1996-1998
  7.    Copyright (C) Paul Ashton  1997-1998.
  8.    
  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 2 of the License, or
  12.    (at your option) any later version.
  13.    
  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  18.    
  19.    You should have received a copy of the GNU General Public License
  20.    along with this program; if not, write to the Free Software
  21.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. */
  23. /*
  24.    This file handles reply_ calls on named pipes that the server
  25.    makes to handle specific protocols
  26. */
  27.  
  28.  
  29. #include "includes.h"
  30. #include "trans2.h"
  31.  
  32. #define    PIPE        "\\PIPE\\"
  33. #define    PIPELEN        strlen(PIPE)
  34.  
  35. #define REALLOC(ptr,size) Realloc(ptr,MAX((size),4*1024))
  36.  
  37. /* look in server.c for some explanation of these variables */
  38. extern int Protocol;
  39. extern int DEBUGLEVEL;
  40. extern char magic_char;
  41. extern BOOL case_sensitive;
  42. extern pstring sesssetup_user;
  43. extern int Client;
  44. extern fstring myworkgroup;
  45.  
  46. #define VALID_PNUM(pnum)   (((pnum) >= 0) && ((pnum) < MAX_OPEN_PIPES))
  47. #define OPEN_PNUM(pnum)    (VALID_PNUM(pnum) && Pipes[pnum].open)
  48. #define PNUM_OK(pnum,c) (OPEN_PNUM(pnum) && (c)==Pipes[pnum].cnum)
  49.  
  50. /* this macro should always be used to extract an pnum (smb_fid) from
  51.    a packet to ensure chaining works correctly */
  52. #define GETPNUM(buf,where) (chain_pnum!= -1?chain_pnum:SVAL(buf,where))
  53.  
  54. char * known_pipes [] =
  55. {
  56.   "lsarpc",
  57. #if NTDOMAIN
  58.   "NETLOGON",
  59.   "srvsvc",
  60.   "wkssvc",
  61.   "samr",
  62. #endif
  63.   NULL
  64. };
  65.  
  66. /****************************************************************************
  67.   reply to an open and X on a named pipe
  68.  
  69.   This code is basically stolen from reply_open_and_X with some
  70.   wrinkles to handle pipes.
  71. ****************************************************************************/
  72. int reply_open_pipe_and_X(char *inbuf,char *outbuf,int length,int bufsize)
  73. {
  74.   pstring fname;
  75.   int cnum = SVAL(inbuf,smb_tid);
  76.   int pnum = -1;
  77.   int smb_ofun = SVAL(inbuf,smb_vwv8);
  78.   int size=0,fmode=0,mtime=0,rmode=0;
  79.   int i;
  80.  
  81.   /* XXXX we need to handle passed times, sattr and flags */
  82.   pstrcpy(fname,smb_buf(inbuf));
  83.  
  84.   /* If the name doesn't start \PIPE\ then this is directed */
  85.   /* at a mailslot or something we really, really don't understand, */
  86.   /* not just something we really don't understand. */
  87.   if ( strncmp(fname,PIPE,PIPELEN) != 0 )
  88.     return(ERROR(ERRSRV,ERRaccess));
  89.  
  90.   DEBUG(4,("Opening pipe %s.\n", fname));
  91.  
  92.   /* Strip \PIPE\ off the name. */
  93.   pstrcpy(fname,smb_buf(inbuf) + PIPELEN);
  94.  
  95.   /* See if it is one we want to handle. */
  96.   for( i = 0; known_pipes[i] ; i++ )
  97.     if( strcmp(fname,known_pipes[i]) == 0 )
  98.       break;
  99.  
  100.   if ( known_pipes[i] == NULL )
  101.     return(ERROR(ERRSRV,ERRaccess));
  102.  
  103.   /* Known pipes arrive with DIR attribs. Remove it so a regular file */
  104.   /* can be opened and add it in after the open. */
  105.   DEBUG(3,("Known pipe %s opening.\n",fname));
  106.   smb_ofun |= 0x10;        /* Add Create it not exists flag */
  107.  
  108.   pnum = open_rpc_pipe_hnd(fname, cnum);
  109.   if (pnum < 0) return(ERROR(ERRSRV,ERRnofids));
  110.  
  111.   /* Prepare the reply */
  112.   set_message(outbuf,15,0,True);
  113.  
  114.   /* Mark the opened file as an existing named pipe in message mode. */
  115.   SSVAL(outbuf,smb_vwv9,2);
  116.   SSVAL(outbuf,smb_vwv10,0xc700);
  117.  
  118.   if (rmode == 2)
  119.   {
  120.     DEBUG(4,("Resetting open result to open from create.\n"));
  121.     rmode = 1;
  122.   }
  123.  
  124.   SSVAL(outbuf,smb_vwv2, pnum + 0x800); /* mark file handle up into high range */
  125.   SSVAL(outbuf,smb_vwv3,fmode);
  126.   put_dos_date3(outbuf,smb_vwv4,mtime);
  127.   SIVAL(outbuf,smb_vwv6,size);
  128.   SSVAL(outbuf,smb_vwv8,rmode);
  129.   SSVAL(outbuf,smb_vwv11,0);
  130.  
  131.   return chain_reply(inbuf,outbuf,length,bufsize);
  132. }
  133.  
  134.  
  135. /****************************************************************************
  136.   reply to a close
  137. ****************************************************************************/
  138. int reply_pipe_close(char *inbuf,char *outbuf)
  139. {
  140.   int pnum = get_rpc_pipe_num(inbuf,smb_vwv0);
  141.   int cnum = SVAL(inbuf,smb_tid);
  142.   int outsize = set_message(outbuf,0,0,True);
  143.  
  144.   DEBUG(5,("reply_pipe_close: pnum:%x cnum:%x\n", pnum, cnum));
  145.  
  146.   if (!close_rpc_pipe_hnd(pnum, cnum)) return(ERROR(ERRDOS,ERRbadfid));
  147.  
  148.   return(outsize);
  149. }
  150.  
  151.  
  152. /****************************************************************************
  153.  api_LsarpcSNPHS
  154.  
  155.  SetNamedPipeHandleState on \PIPE\lsarpc. 
  156. ****************************************************************************/
  157. BOOL api_LsarpcSNPHS(int pnum, int cnum, char *param)
  158. {
  159.   uint16 id;
  160.  
  161.   if (!param) return False;
  162.  
  163.   id = param[0] + (param[1] << 8);
  164.   DEBUG(4,("lsarpc SetNamedPipeHandleState to code %x\n",id));
  165.  
  166.   return set_rpc_pipe_hnd_state(pnum, cnum, id);
  167. }
  168.  
  169.  
  170. /****************************************************************************
  171.  api_LsarpcTNP
  172.  
  173.  TransactNamedPipe on \PIPE\lsarpc.
  174. ****************************************************************************/
  175. static void LsarpcTNP1(char *data,char **rdata, int *rdata_len)
  176. {
  177.   uint32 dword1, dword2;
  178.   char pname[] = "\\PIPE\\lsass";
  179.  
  180.   /* All kinds of mysterious numbers here */
  181.   *rdata_len = 68;
  182.   *rdata = REALLOC(*rdata,*rdata_len);
  183.  
  184.   dword1 = IVAL(data,0xC);
  185.   dword2 = IVAL(data,0x10);
  186.  
  187.   SIVAL(*rdata,0,0xc0005);
  188.   SIVAL(*rdata,4,0x10);
  189.   SIVAL(*rdata,8,0x44);
  190.   SIVAL(*rdata,0xC,dword1);
  191.   
  192.   SIVAL(*rdata,0x10,dword2);
  193.   SIVAL(*rdata,0x14,0x15);
  194.   SSVAL(*rdata,0x18,sizeof(pname));
  195.   pstrcpy(*rdata + 0x1a,pname);
  196.   SIVAL(*rdata,0x28,1);
  197.   memcpy(*rdata + 0x30, data + 0x34, 0x14);
  198. }
  199.  
  200. static void LsarpcTNP2(char *data,char **rdata, int *rdata_len)
  201. {
  202.   uint32 dword1;
  203.  
  204.   /* All kinds of mysterious numbers here */
  205.   *rdata_len = 48;
  206.   *rdata = REALLOC(*rdata,*rdata_len);
  207.  
  208.   dword1 = IVAL(data,0xC);
  209.  
  210.   SIVAL(*rdata,0,0x03020005);
  211.   SIVAL(*rdata,4,0x10);
  212.   SIVAL(*rdata,8,0x30);
  213.   SIVAL(*rdata,0xC,dword1);
  214.   SIVAL(*rdata,0x10,0x18);
  215.   SIVAL(*rdata,0x1c,0x44332211);
  216.   SIVAL(*rdata,0x20,0x88776655);
  217.   SIVAL(*rdata,0x24,0xCCBBAA99);
  218.   SIVAL(*rdata,0x28,0x11FFEEDD);
  219. }
  220.  
  221. static void LsarpcTNP3(char *data,char **rdata, int *rdata_len)
  222. {
  223.   uint32 dword1;
  224.   uint16 word1;
  225.   char * workgroup = myworkgroup;
  226.   int wglen = strlen(workgroup);
  227.   int i;
  228.  
  229.   /* All kinds of mysterious numbers here */
  230.   *rdata_len = 90 + 2 * wglen;
  231.   *rdata = REALLOC(*rdata,*rdata_len);
  232.  
  233.   dword1 = IVAL(data,0xC);
  234.   word1 = SVAL(data,0x2C);
  235.  
  236.   SIVAL(*rdata,0,0x03020005);
  237.   SIVAL(*rdata,4,0x10);
  238.   SIVAL(*rdata,8,0x60);
  239.   SIVAL(*rdata,0xC,dword1);
  240.   SIVAL(*rdata,0x10,0x48);
  241.   SSVAL(*rdata,0x18,0x5988);    /* This changes */
  242.   SSVAL(*rdata,0x1A,0x15);
  243.   SSVAL(*rdata,0x1C,word1);
  244.   SSVAL(*rdata,0x20,6);
  245.   SSVAL(*rdata,0x22,8);
  246.   SSVAL(*rdata,0x24,0x8E8);    /* So does this */
  247.   SSVAL(*rdata,0x26,0x15);
  248.   SSVAL(*rdata,0x28,0x4D48);    /* And this */
  249.   SSVAL(*rdata,0x2A,0x15);
  250.   SIVAL(*rdata,0x2C,4);
  251.   SIVAL(*rdata,0x34,wglen);
  252.   for ( i = 0 ; i < wglen ; i++ )
  253.     (*rdata)[0x38 + i * 2] = workgroup[i];
  254.    
  255.   /* Now fill in the rest */
  256.   i = 0x38 + wglen * 2;
  257.   SSVAL(*rdata,i,0x648);
  258.   SIVAL(*rdata,i+2,4);
  259.   SIVAL(*rdata,i+6,0x401);
  260.   SSVAL(*rdata,i+0xC,0x500);
  261.   SIVAL(*rdata,i+0xE,0x15);
  262.   SIVAL(*rdata,i+0x12,0x2372FE1);
  263.   SIVAL(*rdata,i+0x16,0x7E831BEF);
  264.   SIVAL(*rdata,i+0x1A,0x4B454B2);
  265. }
  266.  
  267. static void LsarpcTNP4(char *data,char **rdata, int *rdata_len)
  268. {
  269.   uint32 dword1;
  270.  
  271.   /* All kinds of mysterious numbers here */
  272.   *rdata_len = 48;
  273.   *rdata = REALLOC(*rdata,*rdata_len);
  274.  
  275.   dword1 = IVAL(data,0xC);
  276.  
  277.   SIVAL(*rdata,0,0x03020005);
  278.   SIVAL(*rdata,4,0x10);
  279.   SIVAL(*rdata,8,0x30);
  280.   SIVAL(*rdata,0xC,dword1);
  281.   SIVAL(*rdata,0x10,0x18);
  282. }
  283.  
  284.  
  285. BOOL api_LsarpcTNP(int cnum,int uid, char *param,char *data,
  286.              int mdrcnt,int mprcnt,
  287.              char **rdata,char **rparam,
  288.              int *rdata_len,int *rparam_len)
  289. {
  290.   uint32 id,id2;
  291.  
  292.   id = IVAL(data,0);
  293.  
  294.   DEBUG(4,("lsarpc TransactNamedPipe id %lx\n",id));
  295.   switch (id)
  296.   {
  297.     case 0xb0005:
  298.       LsarpcTNP1(data,rdata,rdata_len);
  299.       break;
  300.  
  301.     case 0x03000005:
  302.       id2 = IVAL(data,8);
  303.       DEBUG(4,("\t- Suboperation %lx\n",id2));
  304.       switch (id2 & 0xF)
  305.       {
  306.         case 8:
  307.           LsarpcTNP2(data,rdata,rdata_len);
  308.           break;
  309.  
  310.         case 0xC:
  311.           LsarpcTNP4(data,rdata,rdata_len);
  312.           break;
  313.  
  314.         case 0xE:
  315.           LsarpcTNP3(data,rdata,rdata_len);
  316.           break;
  317.       }
  318.       break;
  319.   }
  320.   return(True);
  321. }
  322.  
  323.